{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. GCN的另一个缺陷\n",
    "\n",
    "GraphSAGE通过采样邻居的策略解决了GCN只能采用Full Patch训练的问题。在GAT中指出了GCN的另外两个缺点：\n",
    "\n",
    "1) 无法为不同的Neighbor节点指定不同的权重，也就说GCN对于同阶邻域上的不同邻居分配的权重是完全相同的，这限制了GCN模型对于空间信息相关系的捕捉能力；\n",
    "\n",
    "2) GCN聚合临近节点特征的方式与图(Graph)的结构密切相关，这限制了训练所得模型在其它图结构上的泛化能力；\n",
    "\n",
    "## 2. 引入注意力(Attention)机制\n",
    "\n",
    "Graph Attention Network(GAT)将注意力(Attention)机制对邻居节点特征进行加权求和，不同的邻居节点有不同的权重；不同临近节点特征的权重完全取决于节点的特征，独立于图(Graph)结构，从而也能获得更好的泛化能力。\n",
    "\n",
    "Graph Attention Network(GAT)与Graph Convolution Network的核心区别在于：如何聚合一阶邻居的信息。\n",
    "\n",
    "1. GCN中聚合一阶邻居信息的过程如下：\n",
    "\n",
    "$$\n",
    "h_{i}^{(l+1)}=\\sigma\\left(\\sum_{j \\in \\mathcal{N}(i)} \\frac{1}{c_{i j}} W^{(l)} h_{j}^{(l)}\\right)\n",
    "$$\n",
    "\n",
    "其中,$\\mathcal{N}(i)$是所有一阶邻居节点，$c_{ij}$是基于图(Graph)结构的标准化常数，$W^{(l)}$是所有一阶相邻节点共享的权重参数。\n",
    "\n",
    "2. GAT中聚合一阶邻居的信息的过程如下:\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "z_{i}^{(l)} &=W^{(l)} h_{i}^{(l)} \\\\\n",
    "e_{i j}^{(l)} &=\\operatorname{LeakyReLU}\\left(\\vec{a}^{T(l)}\\left(z_{i}^{(l)} \\| z_{j}^{(l)}\\right)\\right) \\\\\n",
    "\\alpha_{i j}^{(l)} &=\\frac{\\exp \\left(e_{i j}^{(l)}\\right)}{\\sum_{k \\in \\mathcal{N}(i)} \\exp \\left(e_{i k}^{(l)}\\right)} \\\\\n",
    "h_{i}^{(l+1)} &=\\sigma\\left(\\sum_{j \\in \\mathcal{N}(i)} \\alpha_{i j}^{(l)} z_{j}^{(l)}\\right)\n",
    "\\end{aligned}\n",
    "$$\n",
    "\n",
    "它与GCN的本质区别在于，它将GCN中聚合邻居节点特征的标准化常数$C_{ij}$替换为注意力权重函数。\n",
    "\n",
    "\n",
    "## 3. Graph Attention Model\n",
    "\n",
    "下面一步步将公式转换为代码。\n",
    "\n",
    "1.首先对输入节点进行进行一次线性变换，从而对顶点的特征进行增维，这是一种常见的特征增强（Feature Augment)的方法。\n",
    "\n",
    "$$\n",
    "z_{i}^{(l)} =W^{(l)} h_{i}^{(l)}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiHeadGATLayer(tf.keras.layers.Layer):\n",
    "    def __init__(self, in_dim, out_dim,\n",
    "                 attn_heads = 1,\n",
    "                 # ....\n",
    "                 kernel_initializer = 'glorot_uniform'):\n",
    "\n",
    "        self.in_dim = in_dim\n",
    "        self.out_dim = out_dim\n",
    "\n",
    "        self.attn_heads = attn_heads\n",
    "\n",
    "        self.kernel_initializer = kernel_initializer\n",
    "        \n",
    "        # ...\n",
    "\n",
    "        self.kernels = []\n",
    "\n",
    "        super(MultiHeadGATLayer, self).__init__()\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        assert len(input_shape) >= 2\n",
    "\n",
    "        for head in range(self.attn_heads):\n",
    "            kernel = self.add_weight(shape=(self.in_dim, self.out_dim),\n",
    "                                     initializer=self.kernel_initializer,\n",
    "                                     regularizer=self.kernel_regularizer,\n",
    "                                     name='kernel_{}'.format(head))\n",
    "            self.kernels.append(kernel)\n",
    "            \n",
    "            # ....\n",
    "\n",
    "        self.built = True\n",
    "\n",
    "    def call(self, inputs, training):\n",
    "        X = inputs[0]\n",
    "\n",
    "        outputs = []\n",
    "        for head in range(self.attn_heads):\n",
    "\n",
    "            kernel = self.kernels[head]\n",
    "\n",
    "            features = tf.matmul(X, kernel)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.计算注意力系数：\n",
    "\n",
    "$$\n",
    "e_{i j}^{(l)} =\\operatorname{LeakyReLU}\\left(\\vec{a}^{T(l)}\\left(z_{i}^{(l)} \\| z_{j}^{(l)}\\right)\\right)\n",
    "$$\n",
    "\n",
    "对于变换后的节点特征进行拼接(concatenate)，然后通过矩阵a把拼接后的高维特征映射到一个实数上，这是通过Single Layer Feedforward Neural Network实现的，网络的激活函数是LeakyReLu。\n",
    "\n",
    "> 什么是LeakyReLu函数？\n",
    "> \n",
    "> ReLu是将所有的负值都设为零，而LeakyReLu是给所有负值赋予一个非零斜率，在本论文中以数学的方式我们可以表示为：\n",
    "> $$y_{i}=\\left\\{\\begin{array}{ll}\n",
    "x_{i} & \\text { if } x_{i} \\geq 0 \\\\\n",
    "0.2 & \\text { if } x_{i} \\leq 0\n",
    "\\end{array}\\right.$$\n",
    ">\n",
    "\n",
    "显然，节点i和节点j的相关性是通过可学习的参数W和a(\\*)完成的。\n",
    "\n",
    "\n",
    "完整的注意力机制公式如下：\n",
    "\n",
    "$$\n",
    "\\alpha_{i j}=\\frac{\\exp \\left(\\operatorname{Leaky} \\operatorname{Re} L u\\left(\\overrightarrow{\\mathrm{a}}^{T}\\left[W \\vec{h}_{i}|| W \\vec{h}_{j}\\right]\\right)\\right)}{\\sum_{k \\in N_{i}} \\exp \\left(\\operatorname{Leaky} \\operatorname{Re} L u\\left(\\overrightarrow{\\mathrm{a}}^{T}\\left[W \\vec{h}_{i}|| W \\vec{h}_{k}\\right]\\right)\\right)}\n",
    "$$\n",
    "\n",
    "效果如下图所示:\n",
    "\n",
    "![](images/mark_attention.png)\n",
    "\n",
    "这里的Attention论文作者称之为Mask Graph Attention，这是因为Attention机制同事考虑了Graph的结构，注意力机制只在邻居节点上进行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def call(self, inputs, training):\n",
    "    X = inputs[0]\n",
    "    A = inputs[1]\n",
    "\n",
    "    N = X.shape[0]\n",
    "\n",
    "    outputs = []\n",
    "    for head in range(self.attn_heads):\n",
    "\n",
    "        kernel = self.kernels[head]\n",
    "\n",
    "        features = tf.matmul(X, kernel)\n",
    "\n",
    "        concat_features = tf.concat(\\\n",
    "                [tf.reshape(tf.tile(features, [1, N]), [N * N, -1]),\\\n",
    "                tf.tile(features, [N, 1])], axis = 1)\n",
    "\n",
    "        concat_features = tf.reshape(concat_features, [N, -1, 2 * self.out_dim])\n",
    "\n",
    "        atten_kernel = self.atten_kernels[head]\n",
    "            \n",
    "        dense = tf.matmul(concat_features, atten_kernel)\n",
    "\n",
    "        dense = tf.keras.layers.LeakyReLU(alpha=0.2)(dense)\n",
    "\n",
    "        dense = tf.reshape(dense, [N, -1])\n",
    "\n",
    "        zero_vec = -9e15 * tf.ones_like(dense)\n",
    "        attention = tf.where(A > 0, dense, zero_vec)\n",
    "\n",
    "        dense = tf.keras.activations.softmax(attention, axis = -1)\n",
    "\n",
    "        dropout_attn = tf.keras.layers.Dropout(self.dropout_rate)(dense, training = training)\n",
    "        dropout_feat = tf.keras.layers.Dropout(self.dropout_rate)(features, training = training)\n",
    "\n",
    "        node_features = tf.matmul(dropout_attn, dropout_feat)\n",
    "        \n",
    "        if self.use_bias:\n",
    "            node_features = tf.add(node_features, self.biases[head])\n",
    "\n",
    "        if self.activation is not None:\n",
    "            node_features = self.activation(node_features)\n",
    "\n",
    "         # ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Multi-head Attention\n",
    "\n",
    "如同卷积神经网络(CNN)中滤波核一样，作者发现将多个Attention拼接起来，每个Attention结构可以学习到不同的空间特征，可以进一步提升网络的表达能力。\n",
    "\n",
    "Attention的拼接的方式为concat或者avg。\n",
    "\n",
    "$$\n",
    "h_{i}^{\\prime}=\\|_{k=1}^{K} \\sigma\\left(\\sum_{j \\in \\mathcal{N}_{i}} \\alpha_{i j}^{k} W^{k} h_{j}\\right)\n",
    "$$\n",
    "\n",
    "$$\n",
    "\\vec{h}_{i}^{\\prime}=\\sigma\\left(\\frac{1}{K} \\sum_{k=1}^{K} \\sum_{j \\in \\mathcal{N}_{i}} \\alpha_{i j}^{k} \\mathbf{W}^{k} \\vec{h}_{j}\\right)\n",
    "$$\n",
    "\n",
    "![](images/multi_head_attention.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def call(self, inputs, training):\n",
    "\n",
    "    outputs = []\n",
    "    for head in range(self.attn_heads):\n",
    "\n",
    "        # attention...\n",
    "        \n",
    "        outputs.append(node_features)\n",
    "\n",
    "    if self.attn_heads_reduction == 'concat':\n",
    "        output = tf.concat(outputs, axis = -1)\n",
    "    else:\n",
    "        output = tf.reduce_mean(tf.stack(outputs), axis=-1)\n",
    "\n",
    "    return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. 网络训练过程\n",
    "\n",
    "训练数据仍然采用Cora DataSet，这里不再详细介绍。数据获取的代码与GraphSAGE也几乎完全相同。这里一个核心的区别是，我把整个Graph切成一个个的小图，同时把Graph的Edge也做了切割，保证Gapha的Edge与Node完全匹配。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train():\n",
    "    for e in range(EPOCHS):\n",
    "        for batch in range(NUM_BATCH_PER_EPOCH):\n",
    "            batch_src_index = np.random.choice(train_index, size=(BTACH_SIZE,))\n",
    "            batch_src_label = train_label[batch_src_index].astype(float)\n",
    "\n",
    "            batch_sampling_x = data.x[batch_src_index]\n",
    "            batch_adj = data.adj[np.ix_(batch_src_index, batch_src_index)]\n",
    "\n",
    "            loss = 0.0\n",
    "            with tf.GradientTape() as tape:\n",
    "                batch_train_logits = model([batch_sampling_x, batch_adj], training = True)\n",
    "                loss = loss_object(batch_src_label, batch_train_logits)\n",
    "                grads = tape.gradient(loss, model.trainable_variables)\n",
    "\n",
    "                optimizer.apply_gradients(zip(grads, model.trainable_variables))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后对网络进行训练(Trainning)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process data ...\n",
      "Loading cora dataset...\n",
      "Dataset has 2708 nodes, 5429 edges, 1433 features.\n",
      "WARNING:tensorflow:Layer graph_attention_model is casting an input tensor from dtype float64 to the layer's dtype of float32, which is new behavior in TensorFlow 2.  The layer has dtype float32 because it's dtype defaults to floatx.\n",
      "\n",
      "If you intended to run this layer in float32, you can safely ignore this warning. If in doubt, this warning is likely only an issue if you are porting a TensorFlow 1.X model to TensorFlow 2.\n",
      "\n",
      "To change all layers to have dtype float64 by default, call `tf.keras.backend.set_floatx('float64')`. To change just this layer, pass dtype='float64' to the layer constructor. If you are the author of this layer, you can disable autocasting by passing autocast=False to the base Layer constructor.\n",
      "\n",
      "Epoch 000 train accuracy: 0.7599999904632568 val accuracy: 0.5028571486473083 test accuracy:0.40625\n",
      "Epoch 001 train accuracy: 0.9266666769981384 val accuracy: 0.5400000214576721 test accuracy:0.4778079688549042\n",
      "Epoch 002 train accuracy: 0.9666666388511658 val accuracy: 0.5571428537368774 test accuracy:0.5294383764266968\n",
      "Epoch 003 train accuracy: 0.9800000190734863 val accuracy: 0.5857142806053162 test accuracy:0.554347813129425\n",
      "Epoch 004 train accuracy: 0.9733333587646484 val accuracy: 0.5685714483261108 test accuracy:0.5036231875419617\n",
      "Epoch 005 train accuracy: 0.9733333587646484 val accuracy: 0.5628571510314941 test accuracy:0.5335144996643066\n",
      "Epoch 006 train accuracy: 0.9800000190734863 val accuracy: 0.545714259147644 test accuracy:0.5375905632972717\n",
      "Epoch 007 train accuracy: 0.9800000190734863 val accuracy: 0.5600000023841858 test accuracy:0.5149456262588501\n",
      "Epoch 008 train accuracy: 0.9800000190734863 val accuracy: 0.5771428346633911 test accuracy:0.5652173757553101\n",
      "Epoch 009 train accuracy: 0.9933333396911621 val accuracy: 0.5428571701049805 test accuracy:0.5321558117866516\n",
      "Epoch 010 train accuracy: 0.9933333396911621 val accuracy: 0.5542857050895691 test accuracy:0.5276268124580383\n",
      "Epoch 011 train accuracy: 0.9866666793823242 val accuracy: 0.5485714077949524 test accuracy:0.5185688138008118\n",
      "Epoch 012 train accuracy: 0.9866666793823242 val accuracy: 0.5799999833106995 test accuracy:0.5398550629615784\n",
      "Epoch 013 train accuracy: 0.9866666793823242 val accuracy: 0.5657142996788025 test accuracy:0.5466485619544983\n",
      "Epoch 014 train accuracy: 0.9866666793823242 val accuracy: 0.5542857050895691 test accuracy:0.508152186870575\n",
      "Epoch 015 train accuracy: 0.9866666793823242 val accuracy: 0.5571428537368774 test accuracy:0.5335144996643066\n",
      "Epoch 016 train accuracy: 0.9933333396911621 val accuracy: 0.5657142996788025 test accuracy:0.5457427501678467\n",
      "Epoch 017 train accuracy: 0.9866666793823242 val accuracy: 0.5828571319580078 test accuracy:0.542119562625885\n",
      "Epoch 018 train accuracy: 0.9933333396911621 val accuracy: 0.5771428346633911 test accuracy:0.5557065010070801\n",
      "Epoch 019 train accuracy: 0.9866666793823242 val accuracy: 0.5771428346633911 test accuracy:0.5439311861991882\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from train_batch import train\n",
    "\n",
    "train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最终的效果如上图所示，在训练集和验证集上的效果均比GraphSAGE有较大差距，并且波动很大，具体原因待进一步追查！"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
